Python Random మాడ్యూల్: సూడోరాండమ్ నంబర్ జనరేషన్ లోతుగా పరిశీలన

కంప్యూటింగ్ ప్రపంచంలో, యాదృచ్ఛికత అనేది ఒక శక్తివంతమైన మరియు అవసరమైన భావన. సంక్లిష్టమైన శాస్త్రీయ అనుకరణలు మరియు యంత్ర అభ్యాస నమూనాల నుండి వీడియో గేమ్‌లు మరియు సురక్షిత డేటా ఎన్‌క్రిప్షన్ వరకు ప్రతిదానికీ ఇది ఇంజిన్. పైథాన్‌తో పని చేస్తున్నప్పుడు, ఈ అవకాశాన్ని పరిచయం చేయడానికి ప్రధాన సాధనం అంతర్నిర్మిత random మాడ్యూల్. అయినప్పటికీ, ఇది అందించే 'యాదృచ్ఛికత' ఒక ముఖ్యమైన హెచ్చరికతో వస్తుంది: ఇది నిజంగా యాదృచ్ఛికం కాదు. ఇది సూడోరాండమ్.

ఈ సమగ్ర గైడ్ మిమ్మల్ని పైథాన్ యొక్క random మాడ్యూల్‌లోకి లోతుగా పరిశీలిస్తుంది. మేము సూడోరాండమ్‌నెస్‌ను అర్థం చేసుకుంటాము, ఆచరణాత్మక ఉదాహరణలతో మాడ్యూల్ యొక్క ప్రధాన ఫంక్షన్లను అన్వేషిస్తాము మరియు ముఖ్యంగా, దీన్ని ఎప్పుడు ఉపయోగించాలి మరియు భద్రతా-సెన్సిటివ్ అప్లికేషన్‌ల కోసం మరింత బలమైన సాధనం కోసం ఎప్పుడు చేరుకోవాలో చర్చిస్తాము. మీరు డేటా శాస్త్రవేత్త అయినా, గేమ్ డెవలపర్ అయినా లేదా సాఫ్ట్‌వేర్ ఇంజనీర్ అయినా, ఈ మాడ్యూల్ గురించి దృఢమైన అవగాహన మీ పైథాన్ టూల్‌కిట్‌కు అవసరం.

సూడోరాండమ్‌నెస్ అంటే ఏమిటి?

సంఖ్యలను ఉత్పత్తి చేయడం ప్రారంభించే ముందు, మనం పని చేస్తున్న దాని స్వభావాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం. కంప్యూటర్ ఒక నిర్ధారణ యంత్రం; ఇది సూచనలను ఖచ్చితంగా అనుసరిస్తుంది. ఇది, దాని స్వభావం ద్వారా, గాలి నుండి నిజంగా యాదృచ్ఛిక సంఖ్యను ఉత్పత్తి చేయలేకపోతుంది. నిజమైన యాదృచ్ఛికతను వాతావరణ శబ్దం లేదా రేడియోధార్మిక క్షయం వంటి అనూహ్యమైన భౌతిక దృగ్విషయాల నుండి మాత్రమే పొందవచ్చు.

బదులుగా, ప్రోగ్రామింగ్ భాషలు Pseudorandom Number Generators (PRNGs) ను ఉపయోగిస్తాయి. PRNG అనేది ఒక ప్రారంభ విలువ ద్వారా పూర్తిగా నిర్ణయించబడే సంఖ్యల శ్రేణిని ఉత్పత్తి చేసే ఒక అధునాతన అల్గారిథం, దీనిని seed అంటారు.

• నిర్ధారిత అల్గారిథం: సంఖ్యల శ్రేణి గణిత సూత్రం ద్వారా ఉత్పత్తి చేయబడుతుంది. మీరు అల్గారిథం మరియు ప్రారంభ బిందువును తెలిస్తే, మీరు శ్రేణిలోని ప్రతి సంఖ్యను can చేయవచ్చు.
• The Seed: ఇది అల్గారిథంకు ప్రారంభ ఇన్పుట్. మీరు PRNGకి అదే విత్తనాన్ని అందిస్తే, అది ప్రతిసారీ 'యాదృచ్ఛిక' సంఖ్యల యొక్క అదే శ్రేణిని ఉత్పత్తి చేస్తుంది.
• కాలం: PRNG ద్వారా ఉత్పత్తి చేయబడిన సంఖ్యల శ్రేణి చివరికి పునరావృతమవుతుంది. మంచి PRNG కోసం, ఈ కాలం ఖగోళంగా పెద్దది, ఇది చాలా అనువర్తనాల కోసం ఆచరణాత్మకంగా అనంతంగా ఉంటుంది.

పైథాన్ యొక్క random మాడ్యూల్ Mersenne Twister అల్గారిథమ్‌ను ఉపయోగిస్తుంది, ఇది చాలా ప్రజాదరణ పొందిన మరియు దృఢమైన PRNG, ఇది చాలా పొడవైన కాలం కలిగి ఉంది (2¹⁹⁹³⁷-1). ఇది అనుకరణలు, గణాంక నమూనా మరియు గేమింగ్‌కు చాలా బాగుంది, కాని తరువాత చూసినట్లుగా, దాని ఊహాత్మకత దీనిని క్రిప్టోగ్రఫీకి పనికిరాకుండా చేస్తుంది.

జనరేటర్‌ను సీడింగ్ చేయడం: పునరుత్పాదకతకు కీలకం

విత్తనం ద్వారా 'యాదృచ్ఛిక' శ్రేణిని నియంత్రించగల సామర్థ్యం లోపం కాదు; ఇది ఒక శక్తివంతమైన లక్షణం. ఇది పునరుత్పాదకతను హామీ ఇస్తుంది, ఇది శాస్త్రీయ పరిశోధన, పరీక్ష మరియు డీబగ్గింగ్‌లో చాలా అవసరం. మీరు ఒక యంత్ర అభ్యాస ప్రయోగాన్ని అమలు చేస్తుంటే, ఫలితాలను సరిగ్గా పోల్చడానికి మీ యాదృచ్ఛిక బరువు ప్రారంభాలు లేదా డేటా షఫుల్స్ ప్రతిసారీ ఒకేలా ఉన్నాయని మీరు నిర్ధారించుకోవాలి.

దీనిని నియంత్రించడానికి ఫంక్షన్ random.seed().

ఇది ఎలా పని చేస్తుందో చూద్దాం. మొదట, విత్తనాన్ని సెట్ చేయకుండా స్క్రిప్ట్‌ను నడుపుదాం:

            import random

print(random.random())
print(random.randint(1, 100))
            

              
                Copy
              
            
          

మీరు ఈ కోడ్‌ను బహుళసార్లు అమలు చేస్తే, మీరు ప్రతిసారీ వేర్వేరు ఫలితాలను పొందుతారు. మీరు విత్తనాన్ని అందించకపోతే, పైథాన్ స్వయంచాలకంగా ఆపరేటింగ్ సిస్టమ్ నుండి ప్రస్తుత సిస్టమ్ సమయం వంటి నిర్ధారించబడని మూలాన్ని ఉపయోగిస్తుంది, జనరేటర్‌ను ప్రారంభించడానికి.

ఇప్పుడు, విత్తనాన్ని సెట్ చేద్దాం:

            import random

# Run 1
random.seed(42)
print("Run 1:")
print(random.random())  # Output: 0.6394267984578837
print(random.randint(1, 100)) # Output: 82

# Run 2
random.seed(42)
print("\nRun 2:")
print(random.random())  # Output: 0.6394267984578837
print(random.randint(1, 100)) # Output: 82
            

              
                Copy
              
            
          

మీరు చూడగలిగినట్లుగా, అదే విత్తనం (సంఖ్య 42 ఒక సాంప్రదాయ ఎంపిక, కానీ ఏదైనా పూర్ణాంకం సరిపోతుంది) తో జనరేటర్‌ను ప్రారంభించడం ద్వారా, మనం అదే సంఖ్యల శ్రేణిని పొందుతాము. పునరుత్పాదక అనుకరణలు మరియు ప్రయోగాలు చేయడానికి ఇది మూలస్తంభం.

సంఖ్యలను ఉత్పత్తి చేయడం: పూర్ణాంకాలు మరియు ఫ్లోట్‌లు

random మాడ్యూల్ వివిధ రకాల సంఖ్యలను ఉత్పత్తి చేయడానికి గొప్ప ఫంక్షన్లను అందిస్తుంది.

పూర్ణాంకాలను ఉత్పత్తి చేయడం

• random.randint(a, b)

  మీరు ఉపయోగించే అవకాశం ఉన్న అత్యంత సాధారణ ఫంక్షన్ ఇదే. ఇది యాదృచ్ఛిక పూర్ణాంకం N ని అందిస్తుంది, తద్వారా a <= N <= b. ఇది రెండు ఎండ్‌పాయింట్‌లను కలిగి ఉందని గమనించండి.

              # Simulate a standard six-sided die roll
  die_roll = random.randint(1, 6)
  print(f"You rolled a {die_roll}")
              
  
                
                  Copy
                
              
            

• random.randrange(start, stop[, step])

  ఈ ఫంక్షన్ మరింత సౌకర్యవంతంగా ఉంటుంది మరియు పైథాన్ యొక్క అంతర్నిర్మిత range() ఫంక్షన్ లాగా ప్రవర్తిస్తుంది. ఇది range(start, stop, step) నుండి యాదృచ్ఛికంగా ఎంచుకున్న మూలకాన్ని అందిస్తుంది. క్లిష్టంగా, ఇది stop విలువను కలిగి ఉండదు.

              # Get a random even number between 0 and 10 (exclusive of 10)
  even_number = random.randrange(0, 10, 2) # Possible outputs: 0, 2, 4, 6, 8
  print(f"A random even number: {even_number}")
  
  # Get a random number from 0 to 99
  num = random.randrange(100) # Equivalent to random.randrange(0, 100, 1)
  print(f"A random number from 0-99: {num}")
              
  
                
                  Copy
                
              
            

ఫ్లోటింగ్-పాయింట్ నంబర్‌లను ఉత్పత్తి చేయడం

• random.random()

  ఇది అత్యంత ప్రాథమిక ఫ్లోట్-జనరేటింగ్ ఫంక్షన్. ఇది అర్ధ-ఓపెన్ పరిధిలో [0.0, 1.0)లో యాదృచ్ఛిక ఫ్లోట్‌ను అందిస్తుంది. అంటే ఇది 0.0ని కలిగి ఉంటుంది, కాని ఎల్లప్పుడూ 1.0 కంటే తక్కువగా ఉంటుంది.

              # Generate a random float between 0.0 and 1.0
  probability = random.random()
  print(f"Generated probability: {probability}")
              
  
                
                  Copy
                
              
            

• random.uniform(a, b)

  నిర్దిష్ట పరిధిలో యాదృచ్ఛిక ఫ్లోట్‌ను పొందడానికి, uniform() ని ఉపయోగించండి. ఇది యాదృచ్ఛిక ఫ్లోటింగ్-పాయింట్ సంఖ్య N ని అందిస్తుంది, తద్వారా a <= N <= b or b <= N <= a.

              # Generate a random temperature in Celsius for a simulation
  temp = random.uniform(15.5, 30.5)
  print(f"Simulated temperature: {temp:.2f}°C")
              
  
                
                  Copy
                
              
            

• ఇతర పంపిణీలు

  ఈ మాడ్యూల్ వాస్తవ ప్రపంచ దృగ్విషయాలను మోడల్ చేసే వివిధ ఇతర పంపిణీలకు మద్దతు ఇస్తుంది, ఇవి ప్రత్యేక అనుకరణలకు చాలా విలువైనవి:

  • random.gauss(mu, sigma): సాధారణ (లేదా గౌసియన్) పంపిణీ, కొలత లోపాలు లేదా IQ స్కోర్‌ల వంటి విషయాలను మోడల్ చేయడానికి ఉపయోగపడుతుంది.
  • random.expovariate(lambd): ఎక్స్‌పోనెన్షియల్ డిస్ట్రిబ్యూషన్, ఇది పాయిజన్ ప్రక్రియలో ఈవెంట్‌ల మధ్య సమయాన్ని మోడల్ చేయడానికి తరచుగా ఉపయోగించబడుతుంది.
  • random.triangular(low, high, mode): త్రిభుజాకార పంపిణీ, మీకు కనిష్ట, గరిష్ట మరియు చాలా అవకాశం ఉన్న విలువ ఉన్నప్పుడు ఉపయోగపడుతుంది.

సీక్వెన్స్‌లతో పనిచేయడం

తరచుగా, మీకు కేవలం యాదృచ్ఛిక సంఖ్య మాత్రమే అవసరం లేదు; మీరు అంశాల సేకరణ నుండి లేదా జాబితాను యాదృచ్ఛికంగా తిరిగి ఆర్డర్ చేయాలి. random మాడ్యూల్ ఇందులో రాణిస్తుంది.

ఎంపికలు మరియు ఎంపికలు చేయడం

• random.choice(seq)

  ఈ ఫంక్షన్ ఒకే, యాదృచ్ఛికంగా ఎంచుకున్న మూలకాన్ని ఖాళీ లేని క్రమం నుండి (జాబితా, ట్యూపుల్ లేదా స్ట్రింగ్ వంటివి) అందిస్తుంది. ఇది చాలా సులభం మరియు ప్రభావవంతంగా ఉంటుంది.

              participants = ["Alice", "Bob", "Charlie", "David", "Eve"]
  winner = random.choice(participants)
  print(f"And the winner is... {winner}!")
  
  possible_moves = ("rock", "paper", "scissors")
  computer_move = random.choice(possible_moves)
  print(f"Computer chose: {computer_move}")
              
  
                
                  Copy
                
              
            

• random.choices(population, weights=None, k=1)

  మరింత సంక్లిష్టమైన దృశ్యాల కోసం, choices() (బహువచనం) మీరు జనాభా నుండి బహుళ మూలకాలను ఎంచుకోవడానికి అనుమతిస్తుంది, పునస్థాపనతో. అంటే ఒకే అంశాన్ని ఒకటి కంటే ఎక్కువ సార్లు ఎంచుకోవచ్చు. మీరు నిర్దిష్ట ఎంపికలను ఇతరులకన్నా ఎక్కువగా చేయడానికి weights జాబితాను కూడా పేర్కొనవచ్చు.

              # Simulate 10 coin flips
  flips = random.choices(["Heads", "Tails"], k=10)
  print(flips)
  
  # Simulate a weighted dice roll where 6 is three times more likely
  outcomes = [1, 2, 3, 4, 5, 6]
  weights = [1, 1, 1, 1, 1, 3]
  weighted_roll = random.choices(outcomes, weights=weights, k=1)[0]
  print(f"Weighted roll result: {weighted_roll}")
              
  
                
                  Copy
                
              
            

• random.sample(population, k)

  మీరు జనాభా నుండి బహుళ ప్రత్యేకమైన అంశాలను ఎంచుకోవలసినప్పుడు, sample()ని ఉపయోగించండి. ఇది పునస్థాపన లేకుండా ఎంపికను నిర్వహిస్తుంది. లాటరీ సంఖ్యలను గీయడం లేదా యాదృచ్ఛిక ప్రాజెక్ట్ బృందాన్ని ఎంచుకోవడం వంటి దృశ్యాలకు ఇది సరైనది.

              # Select 3 unique numbers for a lottery draw from 1 to 50
  lottery_numbers = range(1, 51)
  winning_numbers = random.sample(lottery_numbers, k=3)
  print(f"The winning numbers are: {winning_numbers}")
  
  # Form a random team of 2 from the participant list
  team = random.sample(participants, k=2)
  print(f"The new project team is: {team}")
              
  
                
                  Copy
                
              
            

సీక్వెన్స్‌ను షఫుల్ చేయడం

• random.shuffle(x)

  ఈ ఫంక్షన్ ఒక మార్చగల క్రమంలోని అంశాలను (జాబితా లాంటివి) యాదృచ్ఛికంగా తిరిగి ఆర్డర్ చేయడానికి ఉపయోగించబడుతుంది. shuffle() జాబితాను స్థానంలో సవరిస్తుందని మరియు None ని అందిస్తుందని గుర్తుంచుకోవడం ముఖ్యం. దాని రిటర్న్ విలువను వేరియబుల్‌కు కేటాయించే సాధారణ తప్పు చేయవద్దు.

              # Shuffle a deck of cards
  cards = ["Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"]
  print(f"Original order: {cards}")
  
  random.shuffle(cards)
  print(f"Shuffled order: {cards}")
  
  # Incorrect usage:
  # shuffled_cards = random.shuffle(cards) # This will set shuffled_cards to None!
              
  
                
                  Copy
                
              
            

ఒక ముఖ్యమైన హెచ్చరిక: క్రిప్టోగ్రఫీ లేదా భద్రత కోసం `random`ని ఉపయోగించవద్దు

ఇది ఏ ప్రొఫెషనల్ డెవలపర్ అయినా తెలుసుకోవలసినది. Mersenne Twister PRNG యొక్క ఊహాత్మకత దీనిని భద్రతకు సంబంధించిన ఏ ప్రయోజనం కోసం అయినా పూర్తిగా అసురక్షితం చేస్తుంది. దాడి చేసే వ్యక్తి శ్రేణి నుండి కొన్ని సంఖ్యలను గమనించగలిగితే, వారు విత్తనాన్ని లెక్కించవచ్చు మరియు తదుపరి అన్ని 'యాదృచ్ఛిక' సంఖ్యలను can చేయవచ్చు.

ఎప్పటికీ random మాడ్యూల్‌ని ఉపయోగించవద్దు:

• పాస్‌వర్డ్‌లు, సెషన్ టోకెన్‌లు లేదా API కీలను రూపొందించడం.
• పాస్‌వర్డ్ హాషింగ్ కోసం ఉప్పును సృష్టించడం.
• ఎన్‌క్రిప్షన్ కీలను రూపొందించడం వంటి ఏదైనా క్రిప్టోగ్రాఫిక్ ఫంక్షన్.
• పాస్‌వర్డ్ రీసెట్ విధానాలు.

పని కోసం సరైన సాధనం: `secrets` మాడ్యూల్

భద్రతా-సెన్సిటివ్ అప్లికేషన్‌ల కోసం, పైథాన్ secrets మాడ్యూల్‌ని అందిస్తుంది (పైథాన్ 3.6 నుండి అందుబాటులో ఉంది). ఈ మాడ్యూల్ ఆపరేటింగ్ సిస్టమ్ అందించిన అత్యంత సురక్షితమైన యాదృచ్ఛికతను ఉపయోగించడానికి ప్రత్యేకంగా రూపొందించబడింది. దీనిని సాధారణంగా క్రిప్టోగ్రాఫిక్ సురక్షిత సూడోరాండమ్ నంబర్ జనరేటర్ (CSPRNG)గా సూచిస్తారు.

ఇక్కడ మీరు సాధారణ భద్రతా పనుల కోసం దీన్ని ఎలా ఉపయోగిస్తారో ఉంది:

            import secrets
import string

# Generate a secure, 16-byte token in hexadecimal format
api_key = secrets.token_hex(16)
print(f"Secure API Key: {api_key}")

# Generate a secure URL-safe token
password_reset_token = secrets.token_urlsafe(32)
print(f"Password Reset Token: {password_reset_token}")

# Generate a strong, random password
# This creates a password with at least one lowercase, one uppercase, and one digit
-alphabet = string.ascii_letters + string.digits
password = ''.join(secrets.choice(alphabet) for i in range(12))
print(f"Generated Password: {password}")
            

              
                Copy
              
            
          

నిబంధన చాలా సులభం: ఇది భద్రతను తాకితే, secretsని ఉపయోగించండి. ఇది మోడలింగ్, గణాంకాలు లేదా గేమ్‌ల కోసం అయితే, random సరైన ఎంపిక.

High-Performance Computing కోసం: `numpy.random`

ప్రామాణిక random మాడ్యూల్ సాధారణ-ప్రయోజన పనులకు చాలా బాగుంది, కానీ పెద్ద శ్రేణి సంఖ్యలను ఉత్పత్తి చేయడానికి ఇది ఆప్టిమైజ్ చేయబడలేదు, ఇది డేటా సైన్స్, యంత్ర అభ్యాసం మరియు శాస్త్రీయ కంప్యూటింగ్‌లో సాధారణ అవసరం. ఈ అనువర్తనాల కోసం, NumPy లైబ్రరీ పరిశ్రమ ప్రమాణం.

numpy.random మాడ్యూల్ చాలా ఎక్కువ పనితీరును కలిగి ఉంది, ఎందుకంటే దాని అంతర్లీన అమలు కంపైల్ చేయబడిన C కోడ్‌లో ఉంది. ఇది NumPy యొక్క శక్తివంతమైన శ్రేణి వస్తువులతో సజావుగా పనిచేసేలా రూపొందించబడింది.

ఒక మిలియన్ యాదృచ్ఛిక ఫ్లోట్‌లను రూపొందించడానికి సింటాక్స్‌ను పోల్చుకుందాం:

            import random
import numpy as np
import time

# Using the standard library `random`
start_time = time.time()
random_list = [random.random() for _ in range(1_000_000)]
end_time = time.time()
print(f"Standard 'random' took: {end_time - start_time:.4f} seconds")

# Using NumPy
start_time = time.time()
numpy_array = np.random.rand(1_000_000)
end_time = time.time()
print(f"NumPy 'numpy.random' took: {end_time - start_time:.4f} seconds")
            

              
                Copy
              
            
          

NumPy పరిమాణాత్మకంగా వేగంగా ఉందని మీరు కనుగొంటారు. ఇది బహుళ-డైమెన్షనల్ డేటాతో పనిచేయడానికి విస్తృత శ్రేణి గణాంక పంపిణీలు మరియు సాధనాలను కూడా అందిస్తుంది.

ఉత్తమ పద్ధతులు మరియు చివరి ఆలోచనలు

కొన్ని కీలక ఉత్తమ పద్ధతులతో మన ప్రయాణాన్ని సంగ్రహిద్దాం:

• పునరుత్పాదకత కోసం సీడ్: మీ యాదృచ్ఛిక ప్రక్రియలు పునరావృతం కావాల్సిన అవసరం ఉన్నప్పుడు, పరీక్షలు, అనుకరణలు లేదా యంత్ర అభ్యాస ప్రయోగాలలో, random.seed() ని ఎల్లప్పుడూ ఉపయోగించండి.
• భద్రత మొదటిది: భద్రత లేదా క్రిప్టోగ్రఫీకి సంబంధించిన దేనికైనా random మాడ్యూల్‌ను ఎప్పుడూ ఉపయోగించవద్దు. బదులుగా ఎల్లప్పుడూ secrets మాడ్యూల్‌ని ఉపయోగించండి. ఇది చర్చనీయాంశం కాదు.
• సరైన ఫంక్షన్‌ని ఎంచుకోండి: మీ ఉద్దేశాన్ని ఉత్తమంగా వ్యక్తపరిచే ఫంక్షన్‌ని ఉపయోగించండి. ప్రత్యేకమైన ఎంపిక కావాలా? random.sample() ని ఉపయోగించండి. పునస్థాపనతో ఒక బరువున్న ఎంపిక కావాలా? random.choices() ని ఉపయోగించండి.
• పనితీరు ముఖ్యం: భారీ సంఖ్యాపరమైన ఎత్తివేత కోసం, ముఖ్యంగా పెద్ద డేటాసెట్‌లతో, numpy.random యొక్క శక్తిని మరియు వేగాన్ని పెంచండి.
• స్థానంలో కార్యకలాపాలను అర్థం చేసుకోండి: random.shuffle() జాబితాను స్థానంలో సవరిస్తుందని గుర్తుంచుకోండి.

ముగింపు

పైథాన్ యొక్క random మాడ్యూల్ ప్రామాణిక లైబ్రరీలో ఒక బహుముఖ మరియు అనివార్యమైన భాగం. దాని సూడోరాండమ్ స్వభావాన్ని అర్థం చేసుకోవడం మరియు సంఖ్యలను ఉత్పత్తి చేయడానికి మరియు సీక్వెన్స్‌లతో పనిచేయడానికి దాని ప్రధాన ఫంక్షన్లను నేర్చుకోవడం ద్వారా, మీరు మీ అప్లికేషన్‌లకు శక్తివంతమైన డైనమిక్ ప్రవర్తనను జోడించవచ్చు. మరింత ముఖ్యంగా, దాని పరిమితులను తెలుసుకోవడం మరియు secrets లేదా numpy.random వంటి ప్రత్యేక సాధనాల కోసం ఎప్పుడు చేరుకోవాలో తెలుసుకోవడం ద్వారా, మీరు ఒక ప్రొఫెషనల్ సాఫ్ట్‌వేర్ ఇంజనీర్ యొక్క ముందుచూపు మరియు కృషిని ప్రదర్శిస్తారు. కాబట్టి ముందుకు సాగండి—ఆత్మవిశ్వాసంతో అనుకరించండి, షఫుల్ చేయండి మరియు ఎంచుకోండి!